/**
 * @file EventManager.h
 * @brief 事件管理器头文件，负责事件的发布和订阅
 */

#ifndef EVENTMANAGER_HPP
#define EVENTMANAGER_HPP


#include <functional>
#include <unordered_map>
#include <vector>
#include <memory>
#include <mutex>
#include <queue>
#include <thread>
#include "EventTypes.hpp"
#include "core/ThreadPool.hpp"

namespace WaveGuard {

    /**
     * @class EventListener
     * @brief 事件监听器接口，所有希望接收事件的类都应实现此接口
     */
    class EventListener {
    public:
        virtual ~EventListener() = default;

        /**
         * @brief 处理事件的纯虚函数
         * @param event 要处理的事件
         */
        virtual void onEvent(const std::shared_ptr<Event> &event) = 0;
    };

    /**
     * @class EventCallback
     * @brief 基于回调函数的事件监听器
     */
    class EventCallback : public EventListener {
    public:
        using CallbackFunction = std::function<void(const std::shared_ptr<Event> &)>;

        EventCallback(CallbackFunction callback) : m_callback(callback) {}

        void onEvent(const std::shared_ptr<Event> &event) override {
            if (m_callback) {
                m_callback(event);
            }
        }

    private:
        CallbackFunction m_callback;
    };

    /**
     * @class EventManager
     * @brief 事件管理器，负责事件的发布和订阅
     */
    class EventManager {
    public:
        /**
         * @brief 构造函数
         * @param threadPool 共享的线程池实例
         */
        EventManager(std::shared_ptr<ThreadPool> threadPool);

        /**
         * @brief 析构函数
         */
        ~EventManager();

        /**
         * @brief 注册事件监听器
         * @param type 要监听的事件类型
         * @param listener 事件监听器
         */
        void subscribe(EventType type, std::shared_ptr<EventListener> listener);

        /**
         * @brief 取消注册事件监听器
         * @param type 要取消监听的事件类型
         * @param listener 事件监听器
         */
        void unsubscribe(EventType type, std::shared_ptr<EventListener> listener);

        /**
         * @brief 同步发布事件（立即处理）
         * @param event 要发布的事件
         */
        void publish(const std::shared_ptr<Event> &event);

        /**
         * @brief 异步发布事件（放入队列稍后处理）
         * @param event 要发布的事件
         */
        void publishAsync(const std::shared_ptr<Event> &event);

        /**
         * @brief 处理事件队列中的所有事件
         */
        void processEvents();

        /**
         * @brief 设置事件处理的最大时间
         * @param ms 最大时间（毫秒）
         */
        void setMaxProcessTimeMs(size_t ms);

    private:
        /**
         * @brief 处理单个事件
         * @param event 事件对象
         */
        void processEvent(const std::shared_ptr<Event> &event);

        /**
         * @brief 事件处理任务
         * @param event 事件对象
         */
        void eventProcessingTask(const std::shared_ptr<Event> &event);

    private:
        std::unordered_map<EventType, std::vector<std::shared_ptr<EventListener>>> m_listeners; // 事件监听器映射表：事件类型 -> 监听器列表
        std::shared_ptr<ThreadPool> m_threadPool;        // 线程池实例
        std::queue<std::shared_ptr<Event>> m_eventQueue; // 事件队列（用于异步处理）
        std::mutex m_mutex;                              // 互斥锁，保护共享资源
        size_t m_maxProcessTimeMs;                          // 事件处理的最大时间（毫秒）
    };

} // namespace WaveGuard

#endif // !EVENTMANAGER_HPP